Impara Ruby in 10 minuti

8 October 2025 — Linguaggio Di Programmazione

Ruby è un linguaggio di programmazione dinamico e orientato agli oggetti noto per la sua sintassi elegante e le funzionalità amichevoli per gli sviluppatori. Questo tutorial copre i concetti fondamentali di Ruby per aiutarti a imparare rapidamente il linguaggio.

1. Scrivere il tuo primo programma Ruby

Iniziamo con un programma semplice. Crea un file chiamato hello.rb e inserisci il seguente codice:

puts "Hello, World!"

Salva il file ed esegui il seguente comando nel terminale:

ruby hello.rb

L’output sarà:

Hello, World!

Questo semplice programma dimostra la funzionalità di output di base di Ruby. Il metodo puts viene utilizzato per visualizzare informazioni di testo nella console.

2. Sintassi di base

La sintassi di Ruby è pulita e leggibile, progettata per essere naturale e intuitiva.

# Questo è un commento
puts "Hello, World!"

Regole di sintassi di base in Ruby:

Commenti: I commenti su una riga iniziano con #, mentre i commenti su più righe usano =begin e =end.
Istruzioni: Tipicamente un’istruzione per riga, non è necessario il punto e virgola ; alla fine.
Blocchi di codice: Definiti da do...end o parentesi graffe {}.
Chiamate di metodi: Le parentesi sono opzionali per le chiamate di metodi senza argomenti.

Esempio con commenti su più righe:

=begin
Questo è un commento su più righe,
che si estende su più righe.
=end

3. Variabili e tipi di dati

In Ruby, le variabili sono tipizzate dinamicamente e non richiedono dichiarazioni di tipo esplicite.

Regole di base per la denominazione delle variabili:

I nomi delle variabili possono contenere solo lettere, numeri e underscore.
I nomi delle variabili non possono iniziare con un numero.
I nomi delle variabili sono sensibili alle maiuscole/minuscole.
Le parole chiave di Ruby non possono essere utilizzate come nomi di variabili.

I principali tipi di dati di base di Ruby sono:

Intero (Integer): es. 42 o -10.
Virgola mobile (Float): es. 3.14 o 2.5e3.
Stringa (String): es. "hello" o 'world', usando apici singoli o doppi.
Booleano (Boolean): true o false.
Nil (Nil): Rappresentato da nil, indica nullo o nessun valore.
Simbolo (Symbol): es. :name, identificatori immutabili.

3.1 Tipi numerici

Ruby supporta numeri interi e in virgola mobile.

# Intero
age = 25
population = 1_000_000  # Underscore per leggibilità

# Virgola mobile
temperature = 36.5
pi = 3.14159

# Operazioni
puts 10 + 5   # 15
puts 10 / 3   # 3 (divisione intera)
puts 10.0 / 3 # 3.333... (divisione in virgola mobile)

3.2 Stringhe

Le stringhe sono sequenze di caratteri, racchiuse tra apici singoli o doppi.

single_quote = 'Stringa con apici singoli'
double_quote = "Stringa con apici doppi"
multiline = "Questa è una
stringa su più righe"

# Interpolazione di stringhe (solo con apici doppi)
name = "Alice"
greeting = "Ciao, #{name}!"
puts greeting  # "Ciao, Alice!"

Operazioni sulle stringhe:

text = "Programmazione Ruby"
puts text.length        # Lunghezza della stringa
puts text.upcase        # Converti in maiuscolo
puts text.downcase      # Converti in minuscolo
puts text[0]            # Accedi al primo carattere
puts text[0..3]         # Slicing della stringa
puts text.include?("Ruby")  # Verifica l'inclusione

3.3 Tipo booleano

Il tipo booleano ha due valori: true e false.

is_active = true
is_complete = false

# Operazioni booleane
result1 = true && false  # false
result2 = true || false  # true
result3 = !true          # false

3.4 Tipo Nil

nil rappresenta uno stato nullo o senza valore.

value = nil

if value.nil?
  puts "Il valore è nullo"
end

3.5 Simbolo

I simboli sono identificatori immutabili, spesso usati come chiavi negli hash.

:name
:email
:created_at

# Simboli vs Stringhe
puts :name.object_id == :name.object_id  # true (stesso oggetto)
puts "name".object_id == "name".object_id  # false (oggetti diversi)

4. Strutture dati

Ruby fornisce diverse strutture dati integrate per memorizzare e manipolare dati.

4.1 Array

Un array è una collezione ordinata che può contenere più valori.

numbers = [1, 2, 3, 4, 5]
numbers.push(6)        # Aggiungi elemento
numbers.unshift(0)     # Inserisci all'inizio
numbers.delete(3)      # Rimuovi valore specifico
numbers[0] = 10        # Modifica elemento
puts numbers.inspect   # [10, 2, 4, 5, 6]

Operazioni sugli array:

numbers = [10, 20, 30, 40, 50]
puts numbers[1..3]     # [20, 30, 40]
puts numbers.first     # 10
puts numbers.last      # 50
puts numbers.include?(30)  # true

4.2 Hash

Un hash è una collezione di coppie chiave-valore, simile ai dizionari in altri linguaggi.

student = {
  name: "John",
  age: 20,
  major: "Computer Science"
}

# Accesso e modifica dell'hash
puts student[:name]
student[:age] = 21
student[:gpa] = 3.8

# Iterazione sull'hash
student.each do |key, value|
  puts "#{key}: #{value}"
end

5. Controllo del flusso

Ruby fornisce diverse istruzioni di controllo del flusso per gestire l’esecuzione del programma.

5.1 Istruzioni if

L’istruzione if valuta una condizione ed esegue il suo blocco se la condizione è vera.

age = 20
if age >= 18
  puts "Adulto"
elsif age >= 13
  puts "Adolescente"
else
  puts "Bambino"
end

# if su una riga
puts "Adulto" if age >= 18

5.2 Istruzioni unless

unless è l’opposto di if - esegue quando la condizione è falsa.

age = 15
unless age >= 18
  puts "Non adulto"
end

# unless su una riga
puts "Non adulto" unless age >= 18

5.3 Istruzioni case

Le istruzioni case forniscono un modo pulito per gestire condizioni multiple.

grade = "B"

case grade
when "A"
  puts "Eccellente"
when "B"
  puts "Buono"
when "C"
  puts "Medio"
else
  puts "Necessita miglioramento"
end

5.4 Cicli

Ruby supporta vari costrutti di ciclo.

Ciclo while:

count = 0
while count < 5
  puts count
  count += 1
end

Ciclo until:

count = 0
until count >= 5
  puts count
  count += 1
end

Ciclo for:

for i in 0..4
  puts i
end

Iteratore each:

(0..4).each do |i|
  puts i
end

# Con array
fruits = ["mela", "banana", "ciliegia"]
fruits.each do |fruit|
  puts fruit
end

break e next:

(0..9).each do |i|
  break if i == 5     # Esci dal ciclo
  next if i % 2 == 0  # Salta i numeri pari
  puts i              # Output: 1, 3
end

6. Metodi

I metodi in Ruby sono definiti usando la parola chiave def.

Definizione di metodo di base:

def greet(name)
  "Ciao, #{name}!"
end

# Chiamata del metodo
message = greet("John")
puts message

Parametri predefiniti:

def greet(name, greeting = "Ciao")
  "#{greeting}, #{name}!"
end

puts greet("Alice")          # "Ciao, Alice!"
puts greet("Bob", "Salve")   # "Salve, Bob!"

Argomenti variabili:

def sum_numbers(*numbers)
  numbers.sum
end

puts sum_numbers(1, 2, 3, 4)  # 10

Argomenti con nome:

def create_person(name:, age:, city: "Sconosciuta")
  { name: name, age: age, city: city }
end

person = create_person(name: "Alice", age: 25)
puts person.inspect

7. Blocchi e Procs

I blocchi sono porzioni di codice che possono essere passate ai metodi.

Utilizzo dei blocchi:

# Utilizzo di do...end
3.times do
  puts "Ciao!"
end

# Utilizzo di parentesi graffe
3.times { puts "Ciao!" }

# Blocchi con parametri
(1..3).each do |number|
  puts "Numero: #{number}"
end

Parola chiave Yield:

def run_block
  puts "Prima del blocco"
  yield
  puts "Dopo il blocco"
end

run_block { puts "Dentro il blocco" }

Procs:

I Procs sono oggetti che incapsulano blocchi.

square = Proc.new { |x| x * x }
puts square.call(5)  # 25

# Passaggio di procs ai metodi
def apply_operation(numbers, operation)
  numbers.map { |n| operation.call(n) }
end

numbers = [1, 2, 3, 4]
squares = apply_operation(numbers, square)
puts squares.inspect  # [1, 4, 9, 16]

8. Classi e oggetti

Ruby è un linguaggio puramente orientato agli oggetti dove tutto è un oggetto.

Definizione di classe di base:

class Person
  def initialize(name, age)
    @name = name
    @age = age
  end

  def introduce
    "Sono #{@name}, #{@age} anni"
  end

  def have_birthday
    @age += 1
    "#{@name} ha compiuto gli anni, ora ha #{@age} anni"
  end
end

# Creazione di oggetti
person1 = Person.new("John", 25)
person2 = Person.new("Jane", 30)

puts person1.introduce
puts person2.have_birthday

Metodi di accesso:

class Person
  attr_reader :name    # Accesso in lettura
  attr_writer :age     # Accesso in scrittura
  attr_accessor :city  # Accesso in lettura e scrittura

  def initialize(name, age, city)
    @name = name
    @age = age
    @city = city
  end
end

person = Person.new("Alice", 25, "New York")
puts person.name      # "Alice"
person.age = 26       # Imposta età
person.city = "Boston" # Imposta città
puts person.city      # "Boston"

Metodi di classe e variabili:

class Student
  @@student_count = 0  # Variabile di classe

  def initialize(name)
    @name = name
    @@student_count += 1
  end

  def self.student_count  # Metodo di classe
    @@student_count
  end
end

student1 = Student.new("John")
student2 = Student.new("Jane")
puts Student.student_count  # 2

Ereditarietà:

class Animal
  def initialize(name)
    @name = name
  end

  def speak
    "#{@name} fa un suono"
  end
end

class Dog < Animal
  def speak
    "#{@name} abbaia"
  end
end

class Cat < Animal
  def speak
    "#{@name} miagola"
  end
end

dog = Dog.new("Buddy")
cat = Cat.new("Mimi")

puts dog.speak  # "Buddy abbaia"
puts cat.speak  # "Mimi miagola"

9. Moduli e Mixins

I moduli sono utilizzati per raggruppare metodi e costanti correlati e possono essere mescolati nelle classi.

Definizione di modulo:

module Speakable
  def speak
    "#{@name} dice qualcosa"
  end
end

class Person
  include Speakable

  def initialize(name)
    @name = name
  end
end

person = Person.new("Alice")
puts person.speak  # "Alice dice qualcosa"

Namespacing con moduli:

module Math
  PI = 3.14159

  def self.square(x)
    x * x
  end
end

puts Math::PI        # 3.14159
puts Math.square(5)  # 25

10. Gestione delle eccezioni

Ruby fornisce una robusta gestione delle eccezioni usando begin, rescue, ensure e raise.

Gestione di base delle eccezioni:

begin
  result = 10 / 0
rescue ZeroDivisionError => e
  puts "Impossibile dividere per zero: #{e.message}"
else
  puts "Divisione riuscita"
ensure
  puts "Questo viene sempre eseguito"
end

Sollevamento di eccezioni:

def divide(a, b)
  raise "Impossibile dividere per zero" if b == 0
  a / b
end

begin
  result = divide(10, 0)
rescue => e
  puts "Errore: #{e.message}"
end

11. Operazioni sui file

Ruby fornisce metodi semplici per leggere e scrivere file.

Lettura di file:

# Leggi l'intero file
content = File.read("example.txt")
puts content

# Leggi riga per riga
File.foreach("example.txt") do |line|
  puts line.chomp
end

Scrittura di file:

# Scrivi nel file
File.write("output.txt", "Ciao, Ruby!\n")

# Aggiungi al file
File.open("output.txt", "a") do |file|
  file.puts "Aggiungendo nuovo contenuto."
end

12. Metodi integrati utili

Ruby viene fornito con molti metodi integrati utili.

Metodi per le stringhe:

text = "  Programmazione Ruby  "
puts text.strip        # Rimuovi spazi bianchi
puts text.split(" ")   # Dividi in array
puts text.gsub("Ruby", "Python")  # Sostituisci

Metodi per gli array:

numbers = [3, 1, 4, 1, 5, 9, 2]
puts numbers.sort.inspect      # [1, 1, 2, 3, 4, 5, 9]
puts numbers.uniq.inspect      # [3, 1, 4, 5, 9, 2]
puts numbers.select { |n| n > 3 }.inspect  # [4, 5, 9]

Metodi per gli hash:

person = { name: "Alice", age: 25, city: "New York" }
puts person.keys.inspect    # [:name, :age, :city]
puts person.values.inspect  # ["Alice", 25, "New York"]
puts person.has_key?(:age)  # true

13. Ruby Gems

RubyGems è il gestore di pacchetti di Ruby per installare e gestire librerie.

Installazione di gemme:

gem install rails

Utilizzo di gemme nel codice:

require 'json'

# Analizza JSON
json_string = '{"name": "Alice", "age": 25}'
person = JSON.parse(json_string)
puts person["name"]  # "Alice"

# Genera JSON
person_hash = { name: "Bob", age: 30 }
json_output = JSON.generate(person_hash)
puts json_output  # {"name":"Bob","age":30}

14. Guida di stile Ruby

Ruby ha una forte guida di stile della comunità che promuove codice pulito e leggibile.

Indentazione: Usa 2 spazi per l’indentazione.

Convenzioni di denominazione:

Variabili e metodi: snake_case
Classi e moduli: CamelCase
Costanti: SCREAMING_SNAKE_CASE

Parentesi: Usa le parentesi per le chiamate di metodi con argomenti, ometti per le chiamate di metodi senza argomenti.

Blocchi: Usa do...end per blocchi su più righe, {} per blocchi su una riga.

La sintassi elegante e le potenti funzionalità di Ruby lo rendono un piacere da usare. Il suo focus sulla felicità e la produttività degli sviluppatori lo ha reso popolare per lo sviluppo web, lo scripting e le attività di automazione.